36氪获悉，A股三大指数集体高开，沪指高开0.11%，深成指高开0.21%，创业板指高开0.07%；AI应用概念持续爆发，易点天下、视觉中国等多股涨停涨停，中文在线涨超10%，蓝色光标涨超9%；生物科技、多元金融板块领涨，泓博医药涨停，越秀资本涨超9%；航天军工、半导体板块跌幅居前，航天环宇跌超6%，东方日升跌超5%。

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

36氪获悉，恒指开盘涨1.32%，恒生科技指数涨1.93%；兆易创新上市首日高开45.06%； 科技、AI应用概念领涨，MINIMAX-WP涨超6%，智谱涨超5%，阿里巴巴涨近5%，腾讯控股、京东集团涨超2%；化工、公用事业板块跌幅居前，中国水务跌超1%。

36氪获悉，人民币兑美元中间价报7.0103，调升5个基点。前一交易日中间价报7.0108。

鉴于地缘政治风险加剧、实物短缺以及美联储独立性再次出现不确定性，花旗集团上调了其对贵金属的短期展望。包括Max Layton在内的分析师在电邮中写道，未来0-3个月的黄金目标价从每盎司4200美元上调至每盎司5000美元，白银目标价从每盎司62美元上调至每盎司100美元。（新浪财经）

大家好～ 前面我们陆续掌握了 React 19 的组件、路由、状态管理等核心知识点，今天咱们聚焦一个容易被忽略但至关重要的底层模块——事件系统。

用过 React 的同学都知道，我们在组件中写的事件（如 onClick、onChange）和原生 DOM 事件看似相似，却又存在差异：比如 React 事件的 this 指向默认绑定组件实例、事件对象是合成事件（SyntheticEvent）、事件处理函数默认不会冒泡到原生 DOM 层面。这些差异的背后，都源于 React 对原生事件的封装与优化——核心就是事件代理机制。

很多开发者在实际开发中会遇到“React 事件与原生事件冲突”“事件冒泡不符合预期”等问题，本质上是没理清 React 事件系统与原生事件的关系。今天这篇文章，我们就从“是什么-为什么-怎么做”三个层面，拆解 React 19 事件系统的核心原理，重点说清 React UI 事件与原生 window 事件的关联，结合代码示例和流程图，让你既能理解底层逻辑，也能解决实际开发中的问题～

一、先抛问题：React 事件和原生事件有啥不一样？

在拆解原理前，我们先通过一个简单案例，直观感受 React 事件与原生事件的差异。先看代码：

import { useEffect, useRef } from 'react';

function EventDemo() {
  const btnRef = useRef(null);

  // React 事件：onClick
  const handleReactClick = () => {
    console.log('React 事件：onClick 触发');
  };

  // 原生事件：addEventListener
  useEffect(() => {
    const btn = btnRef.current;
    const handleNativeClick = () => {
      console.log('原生事件：addEventListener 触发');
    };
    btn.addEventListener('click', handleNativeClick);
    return () => {
      btn.removeEventListener('click', handleNativeClick);
    };
  }, []);

  return (
    <button ref={btnRef} onClick={handleReactClick}>
      点击测试
    </button>
  );
}

点击按钮后，控制台输出顺序是：原生事件：addEventListener 触发 → React 事件：onClick 触发。这个顺序是不是和你预期的不一样？

再把案例改一下，给按钮的父元素也添加事件：

import { useEffect, useRef } from 'react';

function EventDemo() {
  const btnRef = useRef(null);
  const parentRef = useRef(null);

  // 父元素 React 事件
  const handleParentReactClick = () => {
    console.log('父元素 React 事件：onClick 触发');
  };

  // 子元素 React 事件
  const handleReactClick = () => {
    console.log('子元素 React 事件：onClick 触发');
  };

  // 父元素原生事件
  useEffect(() => {
    const parent = parentRef.current;
    const handleParentNativeClick = () => {
      console.log('父元素原生事件：addEventListener 触发');
    };
    parent.addEventListener('click', handleParentNativeClick);
    return () => {
      parent.removeEventListener('click', handleParentNativeClick);
    };
  }, []);

  // 子元素原生事件
  useEffect(() => {
    const btn = btnRef.current;
    const handleNativeClick = () => {
      console.log('子元素原生事件：addEventListener 触发');
    };
    btn.addEventListener('click', handleNativeClick);
    return () => {
      btn.removeEventListener('click', handleNativeClick);
    };
  }, []);

  return (
    <div ref={parentRef} onClick={handleParentReactClick} style={{ padding: '20px', border: '1px solid #ccc' }}>
      <button ref={btnRef} onClick={handleReactClick}>
        点击测试
      </button>
    </div>
  );
}

点击按钮后，控制台输出顺序是：

1. 子元素原生事件：addEventListener 触发（原生冒泡阶段先触发子元素）
2. 父元素原生事件：addEventListener 触发（原生冒泡阶段向上传播）
3. 子元素 React 事件：onClick 触发
4. 父元素 React 事件：onClick 触发

这个结果更让人困惑了：为什么原生事件的冒泡顺序和 React 事件的冒泡顺序完全相反？为什么 React 事件总是在原生事件之后触发？要解答这些问题，我们必须先搞懂 React 事件系统的核心——事件代理机制。

二、核心原理 1：React 事件代理机制（事件委托）

React 事件系统的核心优化点就是“事件代理”（也叫事件委托）。在原生 DOM 中，我们通常会给每个元素单独绑定事件；而 React 则是将所有 UI 事件（如 onClick、onChange、onMouseMove 等）都委托给了最顶层的 document 节点（React 17 及之后版本改为委托给 root 节点，即 React 挂载的根容器，如 #root，React 19 延续这一设计）。

1. 事件代理的核心逻辑

简单来说，React 事件代理的流程是：

1. React 组件渲染时，并不会给对应的 DOM 元素直接绑定事件处理函数，而是将事件类型（如 click）、事件处理函数、组件信息等存入一个“事件注册表”；
2. 在 React 挂载的根容器（如 #root）上，统一绑定原生事件（如 addEventListener('click', 统一处理函数)）；
3. 当用户点击元素时，事件会从目标元素原生冒泡到根容器；
4. 根容器的统一处理函数捕获到事件后，会根据事件目标（target）从“事件注册表”中找到对应的 React 事件处理函数，然后执行。

2. 用图例梳理事件代理流程

3. 简化代码模拟 React 事件代理

为了让大家更直观理解，我们用原生 JS 模拟 React 事件代理的核心逻辑：

// 1. 事件注册表：存储 React 组件的事件信息
const eventRegistry = new Map();

// 2. React 根容器（模拟 #root）
const root = document.getElementById('root');

// 3. 统一事件处理函数（根容器绑定的原生事件处理函数）
function handleRootEvent(e) {
  // e.target 是事件的实际目标（如按钮）
  const target = e.target;

  // 从事件注册表中查找当前目标及祖先元素的事件处理函数
  let current = target;
  const handlers = [];

  while (current && current !== root) {
    // 查找当前元素对应的事件处理函数（这里简化为 click 事件）
    const eventKey = `${current.dataset.reactId}-click`;
    if (eventRegistry.has(eventKey)) {
      handlers.push(eventRegistry.get(eventKey));
    }
    // 向上遍历祖先元素（模拟冒泡）
    current = current.parentNode;
  }

  // 执行找到的事件处理函数（顺序：子元素 → 父元素，模拟 React 事件冒泡）
  handlers.forEach(handler => handler(e));
}

// 4. 给根容器绑定原生事件（模拟 React 初始化时的绑定）
root.addEventListener('click', handleRootEvent);

// 5. 模拟 React 组件绑定事件（将事件存入注册表）
function bindReactEvent(reactId, element, eventType, handler) {
  element.dataset.reactId = reactId; // 给元素标记 React ID
  const eventKey = `${reactId}-${eventType}`;
  eventRegistry.set(eventKey, handler);
}

// 6. 测试：创建组件元素并绑定 React 事件
const parentDiv = document.createElement('div');
parentDiv.style.padding = '20px';
parentDiv.style.border = '1px solid #ccc';

const btn = document.createElement('button');
btn.textContent = '点击测试';
parentDiv.appendChild(btn);
root.appendChild(parentDiv);

// 给父元素绑定 React 点击事件
bindReactEvent('parent-1', parentDiv, 'click', () => {
  console.log('父元素 React 事件：onClick 触发');
});

// 给子元素绑定 React 点击事件
bindReactEvent('btn-1', btn, 'click', () => {
  console.log('子元素 React 事件：onClick 触发');
});

// 给子元素绑定原生点击事件
btn.addEventListener('click', () => {
  console.log('子元素原生事件：addEventListener 触发');
});

// 给父元素绑定原生点击事件
parentDiv.addEventListener('click', () => {
  console.log('父元素原生事件：addEventListener 触发');
});

运行这段代码后，点击按钮的输出顺序和我们之前的 React 案例完全一致！这就验证了 React 事件代理的核心逻辑：React 事件是通过根容器的原生事件统一捕获，再通过事件注册表查找并执行对应的处理函数，其“冒泡”是模拟出来的，而非原生 DOM 冒泡。

三、核心原理 2：React UI 事件与原生 window 事件的关系

理解了事件代理机制后，我们就能清晰厘清 React UI 事件与原生 window 事件的关系了。首先要明确两个核心概念：

• React UI 事件：就是我们在组件中写的 onClick、onChange 等事件，是 React 封装后的“合成事件”，依赖事件代理机制执行；
• 原生 window 事件：就是通过 window.addEventListener 绑定的事件（如 resize、scroll、click 等），是浏览器原生支持的事件，遵循原生 DOM 事件流（捕获→目标→冒泡）。

1. 两者的核心关联：事件流的先后顺序

React UI 事件的执行依赖于根容器的原生事件捕获，而根容器是 window 下的一个 DOM 节点。因此，React UI 事件的执行顺序，必然处于原生事件流的“冒泡阶段”（因为事件要先冒泡到根容器，才能被 React 的统一处理函数捕获）。

我们用“原生事件流+React 事件流”的组合流程图，梳理两者的先后关系：

2. 代码验证：React 事件与 window 事件的顺序

我们用代码验证上述流程，给 window 绑定捕获和冒泡阶段的 click 事件：

import { useEffect, useRef } from 'react';

function EventWithWindowDemo() {
  const btnRef = useRef(null);

  // React 事件
  const handleReactClick = () => {
    console.log('React 事件：onClick 触发');
  };

  // 原生事件（目标元素）
  useEffect(() => {
    const btn = btnRef.current;
    const handleBtnNative = () => {
      console.log('目标元素原生事件：冒泡阶段 触发');
    };
    btn.addEventListener('click', handleBtnNative);
    return () => btn.removeEventListener('click', handleBtnNative);
  }, []);

  // window 原生事件（捕获阶段）
  useEffect(() => {
    const handleWindowCapture = (e) => {
      console.log('window 原生事件：捕获阶段 触发');
    };
    // 第三个参数为 true，表示在捕获阶段执行
    window.addEventListener('click', handleWindowCapture, true);
    return () => window.removeEventListener('click', handleWindowCapture, true);
  }, []);

  // window 原生事件（冒泡阶段）
  useEffect(() => {
    const handleWindowBubble = (e) => {
      console.log('window 原生事件：冒泡阶段 触发');
    };
    // 第三个参数省略或为 false，表示在冒泡阶段执行
    window.addEventListener('click', handleWindowBubble);
    return () => window.removeEventListener('click', handleWindowBubble);
  }, []);

  return (
    <button ref={btnRef} onClick={handleReactClick}>
      点击测试（含 window 事件）
    </button>
  );
}

点击按钮后，控制台输出顺序如下，完全符合我们梳理的流程：

1. window 原生事件：捕获阶段 触发（原生捕获阶段从 window 开始）
2. 目标元素原生事件：冒泡阶段 触发（原生目标阶段）
3. React 事件：onClick 触发（事件冒泡到根容器，被 React 捕获执行）
4. window 原生事件：冒泡阶段 触发（事件最终冒泡到 window）

3. 关键结论：React 事件是原生事件的“子集”与“延迟执行”

从上述流程和代码可以得出核心结论：

• React 事件并非脱离原生事件存在，而是基于原生事件实现的封装——React UI 事件的执行，依赖于原生事件冒泡到根容器的过程；
• React 事件的执行时机晚于目标元素及祖先元素的原生事件（因为要等事件冒泡到根容器），但早于 window 上的原生冒泡事件；
• window 上的原生捕获事件，会在整个事件流的最开始执行，甚至早于目标元素的原生事件。

四、核心原理 3：合成事件（SyntheticEvent）与原生事件对象的关系

除了执行顺序，React 事件对象（SyntheticEvent）与原生事件对象也存在差异。在 React 事件处理函数中，我们拿到的 event 不是原生的 Event 对象，而是 React 封装的 SyntheticEvent 对象。

1. 合成事件的核心作用

React 封装 SyntheticEvent 的核心目的是：

• 跨浏览器兼容：不同浏览器的原生事件对象存在差异（如 IE 的 event.srcElement vs 标准的 event.target），SyntheticEvent 统一了这些差异，让开发者无需关注浏览器兼容；
• 事件对象池复用：React 会复用 SyntheticEvent 对象（减少内存开销），事件处理函数执行完后，会清空对象的属性（如 event.target、event.preventDefault() 等）；
• 统一的事件 API：SyntheticEvent 提供了与原生事件对象相似的 API（如 preventDefault、stopPropagation），但行为有细微差异。

2. 合成事件与原生事件对象的关联

SyntheticEvent 对象内部持有原生事件对象的引用，可通过 event.nativeEvent 获取原生事件对象。例如：

const handleReactClick = (event) => {
  console.log(event instanceof SyntheticEvent); // true
  console.log(event.nativeEvent instanceof Event); // true（原生事件对象）
  console.log(event.target === event.nativeEvent.target); // true（统一目标元素）
};

3. 注意点：合成事件的事件阻止

在 React 事件中，调用 event.stopPropagation() 只能阻止 React 事件的“模拟冒泡”（即阻止父组件的 React 事件执行），但无法阻止原生事件的冒泡；如果要阻止原生事件冒泡，需要调用原生事件对象的 stopPropagation()：

const handleReactClick = (event) => {
  console.log('子元素 React 事件触发');
  // 阻止 React 事件的模拟冒泡（父组件的 React 事件不会执行）
  event.stopPropagation();
  // 阻止原生事件的冒泡（父元素的原生事件、window 事件不会执行）
  event.nativeEvent.stopPropagation();
};

注意：在 React 17 之前，合成事件的事件池复用机制会导致“异步访问事件属性失效”（如在 setTimeout 中访问 event.target 会是 null），需要用 event.persist() 保留事件属性；React 17 及之后（包括 React 19），移除了事件池复用机制，异步访问事件属性也能正常获取。

五、实战避坑：React 事件与原生事件协同的常见问题

理解了上述原理后，我们就能解决实际开发中 React 事件与原生事件协同的常见问题了。下面列举 3 个高频问题及解决方案：

问题 1：React 事件与原生事件冒泡冲突，导致重复执行

场景：父组件用 React 事件，子组件用原生事件，点击子组件时，父组件的 React 事件和子组件的原生事件都执行，不符合预期。

解决方案：在子组件的原生事件中，调用原生事件对象的 stopPropagation()，阻止事件冒泡到根容器，从而阻止 React 事件执行：

useEffect(() => {
  const btn = btnRef.current;
  const handleNativeClick = (e) => {
    console.log('子元素原生事件触发');
    e.stopPropagation(); // 阻止原生事件冒泡，React 事件不会执行
  };
  btn.addEventListener('click', handleNativeClick);
  return () => btn.removeEventListener('click', handleNativeClick);
}, []);

问题 2：window 事件未移除，导致内存泄漏

场景：在组件中绑定 window 原生事件（如 resize、scroll），组件卸载后，事件未移除，导致内存泄漏。

解决方案：在 useEffect 的清理函数中，移除 window 事件绑定：

useEffect(() => {
  const handleWindowResize = () => {
    console.log('窗口大小变化');
  };
  window.addEventListener('resize', handleWindowResize);
  // 组件卸载时移除事件
  return () => {
    window.removeEventListener('resize', handleWindowResize);
  };
}, []);

问题 3：React 事件中异步访问事件属性失效（React 17 之前）

场景：在 React 17 及之前版本中，在 setTimeout 中访问 event.target 会是 null。

解决方案：调用 event.persist() 保留事件属性，或提前保存需要的属性：

// 方案 1：调用 event.persist()
const handleReactClick = (event) => {
  event.persist(); // 保留事件属性
  setTimeout(() => {
    console.log(event.target); // 正常获取
  }, 1000);
};

// 方案 2：提前保存属性
const handleReactClick = (event) => {
  const target = event.target; // 提前保存
  setTimeout(() => {
    console.log(target); // 正常获取
  }, 1000);
};

注意：React 17 及之后版本（包括 React 19）已移除事件池复用机制，无需调用 event.persist()，异步访问事件属性也能正常获取。

六、核心总结

今天我们从案例出发，拆解了 React 19 事件系统的核心原理，重点厘清了 React UI 事件与原生 window 事件的关系，最后给出了实战避坑方案。核心要点总结如下：

1. React 事件的核心是事件代理：所有 UI 事件委托给根容器（#root），通过事件注册表查找并执行处理函数，其“冒泡”是模拟的；
2. React 事件与原生事件的顺序：window 原生捕获事件 → 目标元素/祖先元素原生事件 → React 事件 → window 原生冒泡事件；
3. 合成事件是原生事件的封装：提供跨浏览器兼容和统一 API，可通过 event.nativeEvent 获取原生事件对象；
4. 实战避坑关键：阻止原生冒泡需调用 event.nativeEvent.stopPropagation()；window 事件需在组件卸载时移除；React 17 之前异步访问事件属性需用 event.persist()。

七、下一步学习方向

掌握了 React 事件系统的核心原理后，下一步可以重点学习：

• React 19 事件系统的新特性：如对原生事件的进一步优化、与并发渲染的协同等；
• 事件性能优化：如防抖节流在 React 事件中的应用、避免不必要的事件绑定；
• 特殊事件场景：如表单事件（onSubmit、onChange）的特殊处理、拖拽事件与 React 事件的协同。

如果这篇文章对你有帮助，欢迎点赞、收藏、转发～ 有任何问题也可以在评论区留言交流～ 我们下期再见！

36氪获悉，中金计算美国通胀的统计误差，预测通胀将在2025年12月、2026年1月与2026年4月的CPI数据中出现补偿性上涨。如果近期美国通胀偏强，可能导致美联储放慢降息节奏，全球流动性边际收紧，中外大类资产的不确定性可能上升。建议增配商品对冲风险。如果美国通胀与流动性冲击导致中美股票、黄金、美债等资产回调，建议逢低增配。

DeepSeek于12日晚发布新论文《Conditional Memory via Scalable Lookup: A New Axis of Sparsity for Large Language Models》（基于可扩展查找的条件记忆：大型语言模型稀疏性的新维度）。该论文为北京大学与DeepSeek共同完成，合著作者署名中出现梁文锋。论文提出条件记忆（conditional memory），通过引入可扩展的查找记忆结构，在等参数、等算力条件下显著提升模型在知识调用、推理、代码、数学等任务上的表现。同时，DeepSeek开源相关记忆模块Engram。（财联社）

根据金融监管总局网站“金融许可证信息”栏目披露的信息统计，2025年，共有超1.1万家银行线下网点获准退出，超8400家线下网点获准设立。这意味着，2025年银行网点数量净减少逾2000家。业内人士分析，银行网点数量减少主要由中小金融机构改革化险和银行主动关闭低效网点两方面因素所导致。在降本增效的同时，银行也需积极承担社会责任，构建“线上+线下+移动”的立体服务网络。（中证网）

SK海力士计划投资19万亿韩元（129亿美元）建设一座新的先进芯片封装厂，为满足人工智能需求而启动大规模扩张。这家韩国存储芯片巨头在公司网站发布声明称，将于4月份开始建设，目标在2027年底前完工。SK海力士是全球领先的高带宽存储芯片供应商，为英伟达供货。（新浪财经）

1月12日晚间，截至发稿，伦敦现货黄金最高触及4610.68美元/盎司，日内上涨超2%，创历史新高；伦敦现货白银涨幅进一步扩大，日内涨超7%，突破85美元/盎司关口，刷新历史纪录。在金银走强带动下，境内黄金ETF价格集体上涨，国投白银LOF涨逾7%。同时，境内最大的黄金ETF规模已逼近千亿元，白银基金也因市场热情高涨而连续提示溢价风险。而在金价高位运行的背景下，商业银行加大了对黄金相关业务的风险管理力度，多家银行推出挂钩黄金结构性存款。（上证报）

贝莱德正在公司范围内裁减数百个工作岗位，成为近几周来最新一家收缩��力的华尔街公司。据知情人士透露，此次裁员约占贝莱德全球员工总数的1%。他们表示，全公司范围内约250名员工将受到影响，包括投资和销售团队的成员。（新浪财经）

36氪获悉，中信证券研报表示，近期财政部及国家税务总局决定自2026年4月1日起取消光伏等产品增值税出口退税，短期来看，我们预计光伏及储能企业面临出口成本直接增加、盈利能力下降的压力，预计窗口期内光伏组件出货量迅速增加，SMM测算出口退税生效后光伏组件出口量或将下滑5%-10%。我们预计储能龙头海外涨价传导顺利，政策提高出海门槛优化供给，看好海外储能高景气兑现。长远来看，我们认为过去光伏行业凭借低价无序竞争造成的“内卷”状况有望缓解，技术创新迭代及品牌建设有望成为主要方向，落后产能出清速度将会加快，龙头企业市占率继续提升，光伏行业有望迈入高质量发展的新阶段，推荐光伏及储能投资机会。

空客当地时间1月12日公布，2025年空客向全球91家客户交付了793架商用飞机，并在商用飞机业务领域获得1,000架净新订单。截至2025年12月底，订单积压量攀升至8,754架，创下年末历史新高。（界面）

根据Wind1月13日早间更新的数据，截至1月12日收盘华夏基金旗下ETF管理规模突破1万亿元，是ETF这一品种2004年面世以来的首家“万亿”ETF管理人。紧跟其后的是易方达，目前ETF管理规模为9215.17亿元。规模增长之下，全市场ETF规模来到了6.24万亿元。（证券时报）

36氪获悉，截至1月12日，上交所融资余额报13279.20亿元，较前一交易日增加185.87亿元；深交所融资余额报13191.52亿元，较前一交易日增加269.99亿元；两市合计26470.72亿元，较前一交易日增加455.86亿元。

“促进投融资功能协调，必须牢牢抓住提高上市公司质量这个关键。”1月11日，证监会副主席陈华平表示，治理健全、回报水平高或者成长性强的上市公司，本身就是资本市场的源头活水，自然会吸引更多资金长期稳定参与投资，进而形成“上市公司质量高—投资有回报—资金积极入市—融资效率提升”的良性循环。上市公司是市场之基，拥有一批高质量的上市公司，资本市场投资、融资功能才能更好发挥。（证券日报）

2026年以来，多家变压器厂商订单激增，A股变压器板块也随之持续走高。在全球电网建设加速及AIDC（人工智能数据中心）需求的双重驱动下，金盘科技日前与海外客户签订6.96亿元电力产品供货合同，伊戈尔、特变电工、江苏华辰等多家厂商表示在手订单饱满。多名业内人士表示，当前行业供需缺口显著，交货周期大幅拉长，头部企业加速海外产能布局与技术研发，固态变压器（SST）被视作AIDC领域下一代优选方案，不过其大规模商用仍需时日。与此同时，业内预计行业红利期有望延续2年至3年。（上证报）

36氪获悉，华泰证券指出，2026年1月9日，中国财政部、税务总局发布《关于调整光伏等产品出口退税政策的公告》，宣布自2026年4月1日起至2026年12月31日，将电池产品的增值税出口退税率由9%下调至6%，2027年1月1日起，取消电池产品增值税出口退税。华泰证券认为出口退税率的下调短期将推动电池2026年抢出口，加剧锂矿、六氟磷酸锂等环节的供需紧张，长期将推动国内落后产能出清，优化电池行业格局，利好海外产能布局企业。