想象你经营着一家百货大楼:电器、服饰、餐饮全挤在同一层屋檐下,几十个楼层经理共用一把钥匙。卖电器的想调整价签,物业说要全楼停电;餐饮部想换个排风管道,整栋楼要停业三天。随着生意越做越大,这栋楼已经不堪重负。于是你痛下决心,把百货大楼改造成一条步行街:每个品牌拥有独立店铺、独立装修、独立收银,但共享门牌系统、公共水电和物业安保。这条“步行街”,就是微前端的思想——把巨石般的前端应用,拆成多个独立开发、独立部署的子应用,再由主应用像物业一样把它们组合成一个完整街区。本篇文章会带你逛完整条街:为什么必须拆、qiankun 如何给每间铺子装独立电闸、中央厨房如何共享食材、店铺之间如何通信,以及步行街开张后要面对的真实挑战。

岗位关联

掌握微前端拆分思路,你就能在大型前端项目中独立主导模块治理与工程演进,这是高级前端工程师与前端架构师的核心能力之一。

目录
  1. 可视化演示
  2. 巨石应用困境
  3. 拆分核心思想
  4. 沙箱隔离机制
  5. 样式隔离方案
  6. 模块联邦共享
  7. 子应用通信
  8. 落地实践挑战
  9. AI 应用场景
  10. Python 演示
  11. 常见误区
  12. 面试题

可视化演示

本节配有交互动效(进入视口后自动加载,约 3KB)。

构建:5min+ 主应用 (App Shell) 路由分发 | 公共依赖 | 生命周期管理 主应用 (qiankun)

巨石应用困境

一栋老牌百货大楼里,地毯柜台、家电卖场、餐饮区全挤在同一层。家电部想调整一次价签,物业必须全楼停电;餐饮部想换一根排风管道,整栋楼要停业三天。每个部门都觉得自己被拖累,又谁也离不开谁。这就是技术世界中“巨石应用”的日常:所有功能共用一个代码仓库、一个构建产物、一次部署,几十个团队在同一棵树上改枝叶。

在真实的前端项目里,巨石应用的典型特征是散落在 main 分支上的海量 merge:团队 A 改了订单列表的一个组件,团队 B 正在同一个组件上重构,合并时冲突铺满屏幕。更痛苦的是,每次发版都要所有团队对表,任何一个人没准备好,整条流水线就卡住。技术栈也被锁死在当年做技术选型时的版本里——想升级 React、想引入新的构建工具,第一步就要保证全楼不塌。

这三个代价可以浓缩成一个关系式:模块越多,交付成本越高。

百货大楼的老板看着每天停业整顿的公告唉声叹气。他心里清楚:楼不是不够大,而是“一栋楼装下所有人”的协作模式到了天花板。于是,他找来物业规划师,准备把大楼拆成一条步行街。

Cdelivery∝Nmodule\displaystyle C_{\text{delivery}} \propto N_{\text{module}}
  1. \(N_{\text{module}}\)应用里相互依赖的模块总数,模块越多,构建和联调范围越大。
    Nmodule\displaystyle N_{\text{module}}
  2. \(C_{\text{delivery}}\)一次迭代的交付成本,包含编译、测试、联调和发布时间。
    Cdelivery\displaystyle C_{\text{delivery}}
  3. \(\propto\)正比符号,表示模块数量把交付成本线性放大,巨石越大,痛点越尖锐。
    ∝\displaystyle \propto

拆分核心思想

步行街的规划其实不复杂:物业把地块划分成若干铺位,品牌方各自装修、各自收银、各自打烊,而物业只负责公共走廊、门牌号和街区秩序。重要的是,每家店都有独立的门,顾客想进哪家就进哪家,但整条街看起来仍然是一个整体商圈。

微前端正是这样的规划思路:按业务域把前端应用拆成多个子应用,每个子应用由独立团队负责,拥有自己的代码仓库、构建流水线和部署管道。主应用承担“物业”角色,提供外壳框架——包括导航、布局、登录态——并按路由把不同页面区域交给对口的子应用渲染。子应用之间技术栈互不限制:A 团队可以用 Vue,B 团队用 React,主应用不干涉。

把所有部分拼回去,我们得到一个整体画面:

步行街的铺位各干各的,但街区空间仍是一个整体。顾客不会觉得自己进了好几家公司,只觉得“这个商场真大、真方便”——这正是微前端最迷人的地方。

U=Shell⊕⨁i=1nSi\displaystyle U = \text{Shell} \oplus \bigoplus_{i=1}^{n} S_i
  1. \(U\)用户最终看到的完整应用,是步行街整体给人的体验。
    U\displaystyle U
  2. \(\text{Shell}\)主应用外壳,相当于物业管理的公共空间,负责导航、鉴权、布局。
    Shell\displaystyle \text{Shell}
  3. \(\bigoplus_{i=1}^{n} S_i\)从第一个到第 n 个子应用的有序拼接,n 表示拆分出的子应用数量。
    ⨁i=1nSi\displaystyle \bigoplus_{i=1}^{n} S_i
  4. \(\oplus\)组合符号,代表子应用由主应用统一编排,而非代码层面的强行合并。
    ⊕\displaystyle \oplus

沙箱隔离机制

步行街的物业非常谨慎:他们给每家店铺装了独立电闸和一键复位的保险丝盒。任何一家店短路跳闸,只会影响自己,隔壁店铺的灯光纹丝不动。在微前端世界里,这套“电闸系统”就是 JavaScript 沙箱。

子应用运行时总爱往全局 window 对象上挂东西:全局配置、实例对象、插件状态。两个子应用都声明了一个叫 window.store 的变量,后加载的会悄无声息地覆盖先加载的——就像隔壁店的电线接到你家电表上。qiankun 作为主流的微前端框架,用沙箱解决了这个冲突:激活子应用时记录它对 window 的改动,卸载时把 window 还原成激活前的样子。它提供三种沙箱实现,推荐使用的是基于 ES6 Proxy 的 ProxySandbox,性能最好,隔离最彻底。

配合沙箱的还有路由劫持。主应用监听浏览器的 hashchange 和 popstate 事件,一旦 URL 匹配到某个子应用的 activeRule 前缀,就触达该子应用的加载与挂载回调。沙箱记录下来的全局变量差异,可以表示为这样一个集合:

拉闸、合闸、再拉闸。只要保险丝盒里的记录足够准确,隔壁店铺的灯光就永远不受影响。子应用之间的“电流”从此各走各的管道,步行街恢复了井然有序的供电。

diffi={k∣k∈window, windowt1[k]≠windowt0[k]}\displaystyle \text{diff}_i = \{ k \mid k \in \text{window},\ \text{window}_{t_1}[k] \neq \text{window}_{t_0}[k] \}
  1. \(\text{diff}_i\)第 i 个子应用运行期间改动过的全局变量集合,是沙箱“记账本”。
    diffi\displaystyle \text{diff}_i
  2. \(k\)全局对象上的一个键名,例如 store、config 或某个全局函数。
    k\displaystyle k
  3. \(\text{window}_{t_0}[k]\) 与 \(\text{window}_{t_1}[k]\)子应用挂载前与卸载后,同一位键名的值,两者不同说明被改过。
    windowt0[k]≠windowt1[k]\displaystyle \text{window}_{t_0}[k] \neq \text{window}_{t_1}[k]

样式隔离方案

步行街的管理公约里写着一条:每家店铺可以按自己风格装修,但油漆不能刷到别人家的门脸上。这条公约映射到前端,就是“样式隔离”——因为 CSS 天生是全局的,一个子应用写的 .card { color: red },可能覆盖另一个子应用同名类名的样式。

样式冲突的根源在于所有 CSS 最终都注入同一个页面的 style 标签里。为此,工程上发展出几套隔离手段:最朴素的是 CSS 命名空间约定——每个子应用用自己的业务前缀,比如 mall-card、order-card;进阶一点,用构建工具在编译时自动给所有选择器加上前缀;CSS Modules 则直接把类名哈希化,从源头杜绝撞名;还有动态样式表方案——子应用挂载时注入自己的样式,卸载时顺手把 style 标签摘掉。Shadow DOM 是最彻底的方式,样式被锁在组件边界内,但弹层、抽屉等挂到 body 下的组件会突破边界,需要额外处理。

样式冲突的裁决,本质是看选择器优先级,也就是特异度:

比较时从左到右逐位比大小,数值大的一方胜出。微前端要做的事情,就是让每个子应用的“油漆”只在自己的优先级角落里生效。各家涂好各家的墙,公共外立面永远由物业统一维护,步行街五彩斑斓却不混乱。

Specificity=(a, b, c)\displaystyle \text{Specificity} = (a,\ b,\ c)
  1. \(a\)内联样式的数量,优先级最高,任何一个内联样式都可能压过外部样式表。
    a\displaystyle a
  2. \(b\)ID 选择器的数量,ID 在优先级中排第二位。
    b\displaystyle b
  3. \(c\)类选择器、伪类和属性选择器的数量,优先级最低。
    c\displaystyle c

模块联邦共享

步行街运营一段时间后,物业发现一个浪费现象:三家餐饮店各自买了一台和面机、一台烤箱,每天却只用两小时。于是物业建了一个中央厨房,把烘焙设备共享出来,谁家需要谁预约。在微前端里,这个中央厨房叫 Module Federation(模块联邦)。

场景是这样的:用户、订单、营销三个子应用都依赖 React 和一套 UI 组件库。如果各自打包一份,用户访问每个子应用都要重新下载一遍重复的框架代码,首屏性能大打折扣。Webpack 5 的 Module Federation 允许应用在构建时声明“我暴露哪些模块”(exposes)和“我要引用谁的模块”(remotes),真正加载发生在浏览器运行时。更聪明的是 shared 配置:子应用们可以声明共同依赖的库,构建时只要版本兼容,就只保留一份实例,所有应用共用。

如果两个子应用对同一个库要求不同版本怎么办?这正是中央厨房会遇到的档位冲突:

中央厨房共享了设备,也带来了“档位协商”的新问题。但无论如何,比起每家店都买齐整套烤箱,资源已经节省太多。步行街的热气腾腾里,飘着的是同一间厨房的香味。

vshared={max⁡(vA, vB)if vA, vB compatibleduplicateotherwise\displaystyle v_{\text{shared}} = \begin{cases} \max(v_A,\ v_B) & \text{if } v_A,\ v_B \text{ compatible} \\ \text{duplicate} & \text{otherwise} \end{cases}
  1. \(v_A\) 与 \(v_B\)子应用 A 和子应用 B 各自声明的依赖版本约束。
    vA, vB\displaystyle v_A,\ v_B
  2. \(\max(v_A,\ v_B)\)版本兼容时,取较高版本作为共享副本,所有应用一起用它。
    max⁡(vA, vB)\displaystyle \max(v_A,\ v_B)
  3. \(\text{compatible}\)两个版本约束存在交集,可以安全共用一份。
    compatible\displaystyle \text{compatible}
  4. \(\text{duplicate}\)完全无法兼容时,模块联邦会保留多份副本,各自加载各自需要的版本。
    duplicate\displaystyle \text{duplicate}

子应用通信

步行街的店铺各自独立,但有些事必须串通:用户在一家店登录了会员,另一家店也要显示同样的头像;购物车加了商品,满减活动店铺要同步更新优惠信息。物业于是定下规矩:店铺之间不直接拉网线,所有消息都通过物业的公共信箱和公告栏传递。

微前端的跨子应用通信,同样依赖一个“中间人”。常用方式有四种:URL 参数适合传递刷新后仍要保留的信息,比如从列表页跳到详情页的 id;自定义事件适合广播即时通知,任何应用都可以监听;主应用下发 props 是 qiankun 推荐的方式,父组件把回调函数传给子应用;更进一步,可以做集中式状态管理——主应用持有全局状态仓库,子应用读写通过统一接口。qiankun 的 setGlobalState 和 onGlobalStateChange 就是这套机制的官方实现。

如果把全局状态看成一个不断演进的公告板,每次更新可以写成:

任一家店铺改了菜单,物业就在公告栏贴一张通知,需要同步的铺位立刻换价签。没有人直接闯进隔壁改别人的收银系统,整条街的信息却永远保持同步。

G(t+1)=update(G(t), δi)\displaystyle G^{(t+1)} = \text{update}(G^{(t)},\ \delta_i)
  1. \(G^{(t)}\)第 t 时刻的全局状态,就像公告栏当前张贴的所有信息。
    G(t)\displaystyle G^{(t)}
  2. \(\delta_i\)第 i 个子应用提交的变更描述,例如“用户登录了”或“购物车+1”。
    δi\displaystyle \delta_i
  3. \(\text{update}\)主应用执行的状态合并函数,负责把变更安全地应用到全局状态上,再通知其他监听者。
    update\displaystyle \text{update}

落地实践挑战

步行街开张那天锣鼓喧天,但三个月后物业开始头疼:客流高峰时公共通道堵得水泄不通,中央厨房的设备排期越来越紧张,各家店铺的营业时间也不统一。技术图纸再漂亮,运营起来才是真正的考验。微前端落地,同样难在工程治理。

第一个挑战是首屏性能。主应用要把多个子应用的加载策略安排好:按需加载、预加载、缓存,稍有疏忽用户就要盯着白屏等三秒。第二个挑战是公共依赖管理。shared 配置需要精心设计,否则要么重复打包,要么版本冲突把页面搅得天翻地覆。第三个挑战是发布流程——子应用虽然独立部署,但灰度发布和回滚还是要跟主应用协同,先让一部分用户试用新铺子,确认没问题再全量开张。最后是团队规范:路由前缀怎么规划、生命周期命名怎么统一、跨应用的集成测试由谁负责,都需要白纸黑字写进公约。

拆分的成本曲线,可以写成一个简单的式子:

步行街要真正成功,不能只靠铺位多,更要靠一套能长期运转的物业制度。微前端不是银弹,而是一次精细的组织与技术协同手术——拆得聪明,才能走得更远。

cost(n)=∑i=1npi+o(n)\displaystyle \text{cost}(n) = \sum_{i=1}^{n} p_i + o(n)
  1. \(n\)拆分出的子应用数量,也是步行街的铺位数。
    n\displaystyle n
  2. \(p_i\)第 i 个子应用自身的构建、部署、维护成本。
    pi\displaystyle p_i
  3. \(\sum_{i=1}^{n} p_i\)所有子应用的独立成本之和,拆分越细,这部分不一定变少,甚至因为重复基建而变多。
    ∑i=1npi\displaystyle \sum_{i=1}^{n} p_i
  4. \(o(n)\)跨子应用的协作开销,包括联调、集成测试、版本对齐和规范执行,n 越大,开销增长得越快。
    o(n)\displaystyle o(n)

AI 应用场景

电商大促前的中后台巨石应用改造

阶段:架构重构与应用拆分

解决的问题:传统巨石应用中,80 人团队共享一个仓库,每逢大促新功能上线,构建要 20 分钟,任意团队延期都会拖累全站发版。用微前端按业务域拆分为用户、订单、营销三个子应用后,各团队独立开发独立发布,互不阻塞,营销团队还能在大促前单独预发布和灰度。

具体案例:某电商平台双 11 前把营销后台拆成独立子应用,大促当天营销团队单独扩容并灰度新版活动页,即使营销页出问题也只回滚自身,不影响用户下单链路。

AI 训练平台的可视化插件市场

阶段:能力共享与生态集成

解决的问题:算法团队每次更新模型可视化组件,都要等主应用排期发版,迭代周期按周计算。通过 Module Federation 把可视化组件作为远程模块暴露,算法团队独立更新版本,主应用运行时拉取最新模块,发布周期从天级缩短到小时级。

具体案例:某 AI 训练平台把模型训练曲线、特征分布图等可视化组件做成远程模块,算法团队用 React 独立维护,平台主应用与其他子应用直接引用,版本冲突时由 shared 策略自动协商。

多云管理控制台的多团队并存

阶段:隔离与通信协同

解决的问题:云厂商控制台的历史模块用 Vue2 编写,新模块要上 React 18,直接迁移成本过高。用微前端让新旧技术栈并存,通过 qiankun 沙箱隔离全局变量,样式用 CSS Modules 隔离;登录态和地域选择这类公共信息通过全局状态下发给所有子应用。

具体案例:某云厂商控制台将旧版资源管理模块与新版的智能诊断模块同时接入同一主应用,按路由前缀 /res 和 /diag 分发,用户无感切换,团队协作不再互相等待。

Python 演示

python76 行
# 用 Python 模拟微前端的路由分发与沙箱切换import re  class SubApp:    """子应用: 模拟一个可独立部署的前端模块"""     def __init__(self, name, prefix, mount, unmount):        self.name = name        self.prefix = prefix        self.mount = mount        self.unmount = unmount     def match(self, path):        return re.match(self.prefix, path) is not None  class MicroFrontendFramework:    """主应用框架: 负责路由匹配与生命周期调度"""     def __init__(self):        self.apps_registry = []        self.active_app_name = None     def register_app(self, app):        self.apps_registry.append(app)     def stop_current(self, name):        for app in self.apps_registry:            if app.name == name:                app.unmount()                break     def navigate(self, path):        for app in self.apps_registry:            if app.match(path):                if self.active_app_name and self.active_app_name != app.name:                    self.stop_current(self.active_app_name)                if self.active_app_name != app.name:                    app.mount()                    self.active_app_name = app.name                return app        return None  def sandbox_mount(name):    print(f"[沙箱] 开启 {name} 的隔离电闸")    print(f"[沙箱] 记录全局变量 diff: __app__ = {name}")  def sandbox_unmount(name):    print(f"[沙箱] 关闭 {name} 的隔离电闸, 还原全局变量")  def mount_mall_app():    sandbox_mount("商城应用")    print("[挂载] 商城应用: 渲染商品列表页面")  def mount_order_app():    sandbox_mount("订单应用")    print("[挂载] 订单应用: 渲染订单列表页面")  def main():    framework = MicroFrontendFramework()    framework.register_app(SubApp("商城应用", "^/mall", mount_mall_app, sandbox_unmount))    framework.register_app(SubApp("订单应用", "^/order", mount_order_app, sandbox_unmount))     for path in ["/mall/home", "/order/list", "/mall/cart"]:        print(f"\n用户访问: {path}")        framework.navigate(path)  if __name__ == "__main__":    main()
目的:用 Python 还原微前端主应用的核心调度逻辑——按 URL 前缀匹配子应用,切换前卸载旧应用,挂载新应用,并用简单的打印模拟沙箱隔离。
  1. def match(self, path):每个子应用定义自己管理的 URL 前缀,相当于步行街上的门牌号识别规则。
  2. self.apps_registry = []主框架的“铺位清单”,所有注册过的子应用都存在这张表里。
  3. for app in self.apps_registry:每次路由变化,主框架逐个询问哪家铺子负责当前页面。
  4. self.stop_current(self.active_app_name)切换前让旧铺子先打烊,执行卸载逻辑,还原全局变量。
  5. app.mount()新铺子开业,挂载页面并开启沙箱,记录自己的全局变量改动。
  6. if __name__ == "__main__":程序入口,模拟用户连续访问三个路由,观察子应用的激活与销毁顺序。

常见误区

误区把每个子系统包在 iframe 里不就能拆了吗,浏览器天然隔离,何必搞那么复杂。

正解iframe 确实提供隔离,但它会带来整页刷新体验差、父子通信受同源策略限制、弹层和遮罩无法穿透、SEO 不友好等问题。微前端要解决的是“像单页应用一样顺畅,却拥有多应用独立部署能力”的工程问题,远不止一个隔离盒子。步行街要的是各家独立但整体贯通,而不是用一堵高墙把每家店封死。

为何常见:iframe 是 Web 世界里最直观的“盒子”概念,容易让人误以为隔离就是微前端的全部。

误区既然沙箱做了隔离,那我把恶意脚本塞进子应用,它也能挡住吧?

正解qiankun 沙箱解决的是全局变量污染与生命周期恢复,不是安全边界。恶意代码仍可借助 DOM 事件、原型链、Web Worker 等方式逃逸。沙箱更像步行街的独立电闸,能防止一家店短路影响全街,但挡不住故意纵火的人。

为何常见:“隔离”这个词太有安全感,人们容易把工程隔离误解为安全防护。

误区微前端嘛,把应用拆成几十个微小应用,每个组件都独立部署,这样最灵活。

正解微前端拆分的粒度是“业务域”,不是“组件”。拆分越细,跨应用的通信、联调、版本对齐和集成测试成本越高,最终 overhead 会吞掉拆分带来的收益。步行街如果一条街开五十家奶茶店,客流分散、物业疲于奔命,反而不如十家定位清晰的铺子。

为何常见:看到“拆分”二字,容易联想到并发编程里“拆细任务”的思路,但前端应用的拆分单位不是任务,而是组织边界。

误区Module Federation 也能跨应用共享代码,那直接用 MF 就行,不用学 qiankun 了。

正解两者解决的是不同层面的问题。qiankun 负责应用级路由分发、JS 沙箱和生命周期管理;Module Federation 解决构建与运行时的模块共享。它们可以共存:qiankun 决定哪个子应用上场,MF 决定两个应用怎么共享中央厨房的食材。

为何常见:微前端生态里名词太多,功能边界容易被混淆,尤其是“共享”与“隔离”听起来像同一件事。

误区团队约定每个子应用 CSS 都加统一前缀,大家自觉遵守就不会冲突。

正解人工约定随人员流动和项目膨胀一定会被打破。稳妥做法是构建期自动加前缀、CSS Modules 哈希化或动态样式表卸载机制,把隔离从“道德约束”变成“工程强制”。步行街不能只靠商户自觉不占道,要有物业划线并监管。

为何常见:小团队短期约定有效,容易让人把经验错误放大到长期大型项目上。

面试题

Q1. 微前端最核心的价值是什么?

单选题 · easy

  • A.将一个大型应用拆成多个子应用← 正确答案
  • B.用 iframe 隔离所有前端页面
  • C.把所有代码放入单个代码仓库
  • D.用服务端渲染替代客户端渲染

答案:A。微前端的核心是把大型应用按业务域拆成多个可独立开发、独立部署的子应用,并用主应用组合起来。iframe 只是隔离手段且体验差,C 是反方向,D 是渲染技术变革,都不是微前端的定位。

Q2. 巨石应用最典型的协作痛点是什么?

单选题 · easy

  • A.多个团队改同一仓库互相冲突← 正确答案
  • B.页面体积无法压缩到更小
  • C.浏览器兼容问题处理困难
  • D.无法使用最新的浏览器 API

答案:A。巨石应用最痛的是几十个团队在同一仓库里改代码,合并冲突、互相等待、牵一发动全身。B、C、D 是所有前端项目都可能遇到的问题,并不是巨石应用特有的协作困境。

Q3. qiankun 中 JS 沙箱的主要职责是?

单选题 · easy

  • A.隔离子应用之间的全局变量污染← 正确答案
  • B.限制子应用的网络请求频率
  • C.为子应用提供独立数据库
  • D.防止用户进行恶意 DOM 操作

答案:A。JS 沙箱负责记录并还原子应用对 window 全局对象的改动,防止 A 子应用污染 B 子应用。它不限制网络请求,不提供数据库,也不是浏览器的安全机制,后面三个选项都超出了沙箱的能力边界。

Q4. 子应用卸载时,快照沙箱会执行什么操作?

单选题 · mid

  • A.删除子应用挂载的 DOM 节点
  • B.清空浏览器所有本地缓存
  • C.将 window 恢复为激活前状态← 正确答案
  • D.重新加载整个主应用页面

答案:C。快照沙箱在激活时保存一份 window 快照,卸载时把 window 恢复到激活前的状态,就像物业合上电闸前先记下各家电表读数。DOM 删除由框架卸载逻辑负责,与沙箱还原全局变量是两回事。

Q5. 下列哪种方案不能实现样式隔离?

单选题 · mid

  • A.给每个子应用的类名加业务前缀
  • B.构建时用 CSS Modules 生成本地类名
  • C.全站统一使用全局重置样式← 正确答案
  • D.子应用挂载时注入动态样式表

答案:C。全局重置样式非但不能隔离,反而会让所有子应用的样式一起被打回原形,加剧冲突。A、B、D 分别是命名空间、哈希类名和动态注入移除方案,都是有效的样式隔离手段。

Q6. 路由劫持在微前端中的作用是?

单选题 · mid

  • A.让子应用按 URL 匹配并触发激活← 正确答案
  • B.阻止用户访问不存在的路由页面
  • C.将 URL 请求转发到后端服务器
  • D.压缩路由参数以加快传输速度

答案:A。主应用监听 hashchange 和 popstate,当 URL 匹配到某个子应用的 activeRule 前缀时,就触发该子应用的加载与挂载。它不做拦截、不转发、不压缩,核心职责是“按门牌号把顾客带进正确的店铺”。

Q7. Module Federation 中,两个子应用对同一依赖版本要求冲突且无法兼容时,最终结果是?

单选题 · hard

  • A.只保留版本较高的那份依赖
  • B.构建直接报错并终止发布
  • C.两个版本会被分别打入各自应用← 正确答案
  • D.自动改写源码使其兼容

答案:C。模块联邦的版本策略是:版本兼容时取最高版本共享,不兼容时保留多份各自加载,就像中央厨房只有两种温度档位时,餐厅各买各的烤箱。A 只描述了兼容场景的一半,B 和 D 都不是模块联邦的设计行为。

Q8. 下列属于子应用间通信方式的选项有?

多选题 · hard

  • A.主应用下发 props 和全局状态← 正确答案
  • B.通过 URL 参数传递业务信息← 正确答案
  • C.直接修改另一个子应用的源码
  • D.基于自定义事件广播消息← 正确答案

答案:ABD。子应用通信可以通过主应用下发 props、URL 传参、自定义事件和全局状态管理实现。C 修改源码属于架构违规行为,会在下次部署时被覆盖,也破坏了独立开发和独立部署的基本原则。

Q9. 微前端落地时需要考虑的挑战有哪些?

多选题 · mid

  • A.首屏性能与预加载策略← 正确答案
  • B.公共依赖的版本冲突管理← 正确答案
  • C.子应用的代码混淆压缩
  • D.新老团队之间的协作规范← 正确答案

答案:ABD。微前端落地挑战包括首屏性能优化、公共依赖版本治理、灰度发布和团队协作规范。代码混淆压缩是任何前端项目都有的常规构建事项,不是微前端特有的落地挑战。

Q10. 关于 qiankun 沙箱和 Module Federation 的说法,正确的有?

多选题 · extreme

  • A.qiankun 管应用隔离 MF 管模块共享← 正确答案
  • B.两者可在同一微前端架构中使用← 正确答案
  • C.MF 的运行时组件能替代沙箱隔离
  • D.qiankun 沙箱基于 Proxy 或快照实现← 正确答案

答案:ABD。qiankun 负责应用级加载、路由和 JS 沙箱隔离,Module Federation 负责构建与运行时的模块共享,二者是互补关系,可以并存。C 混淆了两者的职责,MF 从不提供全局变量隔离能力;D 正确描述了 qiankun 的沙箱实现路径。