21:I[82591,["8500","static/chunks/8500-01a63dafd809e317.js","9304","static/chunks/9304-8d5d436fe7c94e16.js","7019","static/chunks/7019-14927e506b89eb47.js","8976","static/chunks/8976-2e6983735a6edc4e.js","3265","static/chunks/3265-fd4eae634e948c4f.js","1750","static/chunks/1750-fbdecb7fdfbedc02.js","2623","static/chunks/2623-eea13fee2ab568aa.js","8437","static/chunks/8437-5e456dd2e7c2468a.js","622","static/chunks/622-42e41432bd6994e0.js","3625","static/chunks/3625-83a937e0a1e501ea.js","3227","static/chunks/3227-5950e934b7cd3931.js","3133","static/chunks/3133-9fb39eaee1e47b4c.js","6495","static/chunks/6495-b9b477b9fdf7b8c8.js","4395","static/chunks/app/(web)/(routes)/(web)/flashcards/%5Btrack%5D/%5Bnode%5D/page-14943b4210c1f7e9.js"],"default"] 22:T165b,## 核心思路 `redux-thunk` 的核心能力并不是让归约函数异步执行，而是扩展 `dispatch` 可接受的动作类型。普通动作是带有 `type` 的对象；函数动作则由中间件拦截并立即调用，同时注入 `dispatch`、`getState` 和可选的额外参数。若动作不是函数，中间件必须调用 `next(action)`，让它继续经过后续中间件并最终进入仓库。函数动作的返回值必须原样返回。这样调用者便能通过 `await dispatch(loadUser())` 等待异步任务结束，也能获得函数动作主动返回的业务结果。忽略返回值虽然不一定影响状态更新，却会破坏可组合性和调用方的错误处理。 ```javascript function createThunkMiddleware(extraArgument) { return ({ dispatch, getState }) => next => action => { if (typeof action === 'function') { return action(dispatch, getState, extraArgument); } return next(action); }; } const thunk = createThunkMiddleware(); thunk.withExtraArgument = createThunkMiddleware; export default thunk; ``` 基础版本只有几行代码，但要真正说明其机制，还应展示它如何在业务中使用。下面以依赖注入后的请求为例。额外参数可用于传入接口客户端、日志器或可替换的服务，从而避免函数动作直接依赖全局对象，并提升测试能力。 ```javascript const apiClient = { async getUser(userId) { const response = await fetch(`/api/users/${encodeURIComponent(userId)}`); if (!response.ok) { throw new Error(`request failed: ${response.status}`); } return response.json(); } }; const thunkWithApi = createThunkMiddleware(apiClient); function loadUser(userId) { return async (dispatch, getState, api) => { const current = getState(); if (current.users.loadingById[userId]) { return null; } dispatch({ type: 'USER_REQUESTED', payload: { userId } }); try { const user = await api.getUser(userId); dispatch({ type: 'USER_RECEIVED', payload: { userId, user } }); return user; } catch (error) { dispatch({ type: 'USER_FAILED', payload: { userId, message: String(error.message) }, error: true }); throw error; } }; } async function run(store) { try { const user = await store.dispatch(loadUser('42')); console.log(user); } catch (error) { console.error(error); } } ``` 动作函数可以再次调用增强后的 `dispatch`，因此它既能派发普通对象，也能派发另一个函数动作。这里注入的是中间件接口中的闭包派发函数，而不是绕过中间件链的原始派发函数。`getState` 返回调用时刻的状态；异步等待前取得的状态可能已经过期，因此在关键写入前往往需要重新读取。 ## 执行流程当调用 `dispatch(loadUser('42'))` 时，派发链先收到一个函数。该中间件识别后不调用 `next`，而是执行函数动作。函数动作先派发请求开始对象，这个对象重新进入完整中间件链，并最终交给归约函数；网络请求完成后，成功或失败对象以相同方式再次派发。归约函数始终保持同步和纯净，异步控制流存在于函数动作中。这套机制不负责自动取消请求、去重、缓存、竞态控制或回滚。示例只通过状态避免明显的重复加载，但若用户快速切换查询条件，旧请求可能晚于新请求完成并覆盖最新状态。工程中可使用请求标识、版本号或 `AbortController`，并在归约阶段拒绝过期结果。 ## 复杂度分析中间件检查动作类型只需要 `O(1)` 时间和 `O(1)` 额外空间。若动作是函数，整体复杂度取决于函数动作内部执行的请求、计算和派发次数。每次内部派发仍需经过完整中间件链和归约过程。异步函数产生承诺对象及闭包，但中间件自身不维护队列，也不会创建后台线程。 ## 边界用例需要验证普通对象能够原样传给 `next`，同步函数动作的返回值会被返回，异步函数动作的承诺对象会被返回，函数动作抛出的异常不会被吞掉，额外参数能够正确注入，以及嵌套函数动作仍能通过增强后的派发函数执行。若函数动作忘记返回内部异步调用，外层派发会得到 `undefined`，调用者无法等待任务结束。还要注意函数动作可能读取到陈旧状态。不能把等待前的状态当作等待后的事实。服务端渲染场景也不应将请求相关数据放进跨请求共享的单例仓库，否则不同用户之间可能发生数据污染。 ## 常见错误最常见的错误是对所有动作都调用 `next`，这样函数会进入只接受对象的原始仓库并报错；另一个错误是执行函数动作后没有 `return`，导致派发结果丢失。把参数写成 `action(getState, dispatch)` 会颠倒约定。直接导入全局仓库虽然也能派发，但会造成强耦合、循环依赖和测试困难。函数动作中捕获异常后若既不重新抛出也不返回明确结果，调用方会误以为请求成功。 ## 面试追问面试官可能询问为什么该中间件不需要自己处理承诺对象、函数动作中的 `dispatch` 为什么能再次经过全部中间件、`next` 与 `dispatch` 有何区别、额外参数怎样改善依赖注入，以及如何处理请求竞态与取消。还可能要求比较函数动作和监听式副作用方案：函数动作适合围绕一次用户意图组织直接流程，而复杂的跨动作监听、长生命周期任务和并发协调往往需要更专门的副作用模型。23:T259c,

核心思路

redux-thunk 的核心能力并不是让归约函数异步执行，而是扩展 dispatch 可接受的动作类型。普通动作是带有 type 的对象；函数动作则由中间件拦截并立即调用，同时注入 dispatch、getState 和可选的额外参数。若动作不是函数，中间件必须调用 next(action)，让它继续经过后续中间件并最终进入仓库。

函数动作的返回值必须原样返回。这样调用者便能通过 await dispatch(loadUser()) 等待异步任务结束，也能获得函数动作主动返回的业务结果。忽略返回值虽然不一定影响状态更新，却会破坏可组合性和调用方的错误处理。

function createThunkMiddleware(extraArgument) {
  return ({ dispatch, getState }) => next => action => {
    if (typeof action === 'function') {
      return action(dispatch, getState, extraArgument);
    }

    return next(action);
  };
}

const thunk = createThunkMiddleware();
thunk.withExtraArgument = createThunkMiddleware;

export default thunk;

基础版本只有几行代码，但要真正说明其机制，还应展示它如何在业务中使用。下面以依赖注入后的请求为例。额外参数可用于传入接口客户端、日志器或可替换的服务，从而避免函数动作直接依赖全局对象，并提升测试能力。

const apiClient = {
  async getUser(userId) {
    const response = await fetch(`/api/users/${encodeURIComponent(userId)}`);
    if (!response.ok) {
      throw new Error(`request failed: ${response.status}`);
    }
    return response.json();
  }
};

const thunkWithApi = createThunkMiddleware(apiClient);

function loadUser(userId) {
  return async (dispatch, getState, api) => {
    const current = getState();
    if (current.users.loadingById[userId]) {
      return null;
    }

    dispatch({
      type: 'USER_REQUESTED',
      payload: { userId }
    });

    try {
      const user = await api.getUser(userId);
      dispatch({
        type: 'USER_RECEIVED',
        payload: { userId, user }
      });
      return user;
    } catch (error) {
      dispatch({
        type: 'USER_FAILED',
        payload: { userId, message: String(error.message) },
        error: true
      });
      throw error;
    }
  };
}

async function run(store) {
  try {
    const user = await store.dispatch(loadUser('42'));
    console.log(user);
  } catch (error) {
    console.error(error);
  }
}

动作函数可以再次调用增强后的 dispatch，因此它既能派发普通对象，也能派发另一个函数动作。这里注入的是中间件接口中的闭包派发函数，而不是绕过中间件链的原始派发函数。getState 返回调用时刻的状态；异步等待前取得的状态可能已经过期，因此在关键写入前往往需要重新读取。

执行流程

当调用 dispatch(loadUser('42')) 时，派发链先收到一个函数。该中间件识别后不调用 next，而是执行函数动作。函数动作先派发请求开始对象，这个对象重新进入完整中间件链，并最终交给归约函数；网络请求完成后，成功或失败对象以相同方式再次派发。归约函数始终保持同步和纯净，异步控制流存在于函数动作中。

这套机制不负责自动取消请求、去重、缓存、竞态控制或回滚。示例只通过状态避免明显的重复加载，但若用户快速切换查询条件，旧请求可能晚于新请求完成并覆盖最新状态。工程中可使用请求标识、版本号或 AbortController，并在归约阶段拒绝过期结果。

复杂度分析

中间件检查动作类型只需要 O(1) 时间和 O(1) 额外空间。若动作是函数，整体复杂度取决于函数动作内部执行的请求、计算和派发次数。每次内部派发仍需经过完整中间件链和归约过程。异步函数产生承诺对象及闭包，但中间件自身不维护队列，也不会创建后台线程。

边界用例

需要验证普通对象能够原样传给 next，同步函数动作的返回值会被返回，异步函数动作的承诺对象会被返回，函数动作抛出的异常不会被吞掉，额外参数能够正确注入，以及嵌套函数动作仍能通过增强后的派发函数执行。若函数动作忘记返回内部异步调用，外层派发会得到 undefined，调用者无法等待任务结束。

还要注意函数动作可能读取到陈旧状态。不能把等待前的状态当作等待后的事实。服务端渲染场景也不应将请求相关数据放进跨请求共享的单例仓库，否则不同用户之间可能发生数据污染。

常见错误

最常见的错误是对所有动作都调用 next，这样函数会进入只接受对象的原始仓库并报错；另一个错误是执行函数动作后没有 return，导致派发结果丢失。把参数写成 action(getState, dispatch) 会颠倒约定。直接导入全局仓库虽然也能派发，但会造成强耦合、循环依赖和测试困难。函数动作中捕获异常后若既不重新抛出也不返回明确结果，调用方会误以为请求成功。

面试追问

面试官可能询问为什么该中间件不需要自己处理承诺对象、函数动作中的 dispatch 为什么能再次经过全部中间件、next 与 dispatch 有何区别、额外参数怎样改善依赖注入，以及如何处理请求竞态与取消。还可能要求比较函数动作和监听式副作用方案：函数动作适合围绕一次用户意图组织直接流程，而复杂的跨动作监听、长生命周期任务和并发协调往往需要更专门的副作用模型。

24:T14e9,## 第一段代码的输出代码中的变量 `a` 保存了对象 `{ b: 3 }` 的引用。调用 `foo(a)` 时，形参 `obj` 得到的是同一个对象引用的副本，而不是对象内容的深拷贝。执行 `obj.b = 5` 会修改该共享对象的属性。函数随后返回 `obj`，所以变量 `aa` 与变量 `a` 最终指向同一个对象。 ```javascript const a = { b: 3 } function foo(obj) { obj.b = 5 return obj } const aa = foo(a) console.log(a.b) // 5 console.log(aa.b) // 5 console.log(a === aa) // true ``` 因此两个属性输出都是 `5`，并且 `a === aa` 为 `true`。严格来说，`JavaScript` 的参数传递始终是值传递。区别在于，基本类型变量保存的是基本值，而对象变量保存的是引用值。函数调用会复制这个引用值，于是函数内外的两个变量都能找到同一个对象。将这种行为口语化地称为“对象按引用传递”容易造成误解，因为如果在函数内部重新给形参赋值，并不会改变外部变量本身： ```javascript const source = { value: 1 } function replace(obj) { obj = { value: 2 } return obj } const result = replace(source) console.log(source.value) // 1 console.log(result.value) // 2 console.log(source === result) // false ``` 这里改变的是局部变量 `obj` 保存的引用，而不是原对象。工程中如果函数不应产生副作用，可以返回浅拷贝： ```javascript function update(obj) { return { ...obj, b: 5 } } ``` 但展开语法只进行浅拷贝；嵌套对象仍会共享引用。需要深拷贝时，应根据数据类型选择结构化克隆或明确的数据转换逻辑，不能默认使用序列化方式，因为它无法正确处理所有内建类型、循环引用和特殊值。 ## 第二段代码的输出创建实例时，实例内部的原型关联会指向构造函数在该时刻的 `prototype` 对象。后续把构造函数的 `prototype` 整体替换为另一个对象，不会追溯修改已经创建的实例。 ```javascript function Ofo() {} function Bick() { this.name = 'mybick' } var myBick = new Ofo() Ofo.prototype = new Bick() var youbick = new Bick() console.log(myBick.name) // undefined console.log(youbick.name) // mybick ``` `myBick` 创建时，其原型关联指向旧的 `Ofo.prototype`。旧原型上没有 `name` 属性，所以读取 `myBick.name` 时，先检查实例自身，再沿旧原型链查找，最终得到 `undefined`。执行 `Ofo.prototype = new Bick()` 后，新原型对象自身拥有 `name` 属性，但这一替换只影响之后通过 `new Ofo()` 创建的实例。它也不会影响 `new Bick()` 的正常行为。`youbick` 由 `Bick` 直接构造，构造函数把 `name` 写入实例自身，因此输出字符串 `mybick`。可以增加一个新实例验证区别： ```javascript var nextBick = new Ofo() console.log(nextBick.name) // mybick console.log(Object.getPrototypeOf(myBick) === Ofo.prototype) // false console.log(Object.getPrototypeOf(nextBick) === Ofo.prototype) // true ``` ## 底层机制执行 `new Constructor()` 时，可以概括为创建一个新对象、让该对象的内部原型指向 `Constructor.prototype`、以新对象作为 `this` 调用构造函数，并在构造函数没有显式返回对象时返回这个新对象。关键在于，实例记录的是对当时原型对象的关联，而不是对 `Constructor.prototype` 这个属性位置的动态订阅。因此，修改原型对象上的属性与替换整个原型对象是两种不同操作： ```javascript function Person() {} const first = new Person() Person.prototype.role = 'user' console.log(first.role) // user Person.prototype = { role: 'admin' } console.log(first.role) // user ``` 第一次是在旧原型对象上新增属性，已有实例可以看到；第二次是替换构造函数的原型属性，已有实例仍然连接旧对象。 ## 工程场景与边界在运行期间整体替换构造函数原型容易造成同类实例拥有不同原型链，影响方法查找、类型判断和维护性。若确实采用构造函数继承，应在创建实例之前完成原型配置，并补回正确的 `constructor` 属性。现代业务代码通常可使用 `class` 语法表达继承，但它只是提供更清晰的语法和约束，底层方法查找仍建立在原型机制上。还要注意，写入 `obj.b` 和读取 `obj.b` 的行为并不完全对称。读取会沿原型链查找；普通赋值通常在接收者自身创建或更新属性，但原型链上的访问器、只读属性以及代理对象可能改变这一行为。 ## 常见误区与面试追问常见误区包括：认为对象参数不是值传递；认为重新给形参赋值会替换外部对象；认为修改 `Constructor.prototype` 会同步更新已有实例；以及认为实例的 `constructor` 属性是创建实例时自动复制到实例自身的。实际上，默认的 `constructor` 通常来自原型对象，整体替换原型后可能丢失或指向错误对象。面试中可继续追问：`new` 操作符具体执行哪些步骤、实例属性与原型属性发生同名遮蔽时如何查找、如何用 `Object.getPrototypeOf` 检查真实原型、为什么不建议依赖非标准的 `__proto__` 修改原型，以及浅拷贝和深拷贝分别能隔离哪些变更。25:T2b28,

第一段代码的输出

代码中的变量 a 保存了对象 { b: 3 } 的引用。调用 foo(a) 时，形参 obj 得到的是同一个对象引用的副本，而不是对象内容的深拷贝。执行 obj.b = 5 会修改该共享对象的属性。函数随后返回 obj，所以变量 aa 与变量 a 最终指向同一个对象。

const a = { b: 3 }

function foo(obj) {
  obj.b = 5
  return obj
}

const aa = foo(a)

console.log(a.b)  // 5
console.log(aa.b) // 5
console.log(a === aa) // true

因此两个属性输出都是 5，并且 a === aa 为 true。

严格来说，JavaScript 的参数传递始终是值传递。区别在于，基本类型变量保存的是基本值，而对象变量保存的是引用值。函数调用会复制这个引用值，于是函数内外的两个变量都能找到同一个对象。将这种行为口语化地称为“对象按引用传递”容易造成误解，因为如果在函数内部重新给形参赋值，并不会改变外部变量本身：

const source = { value: 1 }

function replace(obj) {
  obj = { value: 2 }
  return obj
}

const result = replace(source)
console.log(source.value) // 1
console.log(result.value) // 2
console.log(source === result) // false

这里改变的是局部变量 obj 保存的引用，而不是原对象。工程中如果函数不应产生副作用，可以返回浅拷贝：

function update(obj) {
  return { ...obj, b: 5 }
}

但展开语法只进行浅拷贝；嵌套对象仍会共享引用。需要深拷贝时，应根据数据类型选择结构化克隆或明确的数据转换逻辑，不能默认使用序列化方式，因为它无法正确处理所有内建类型、循环引用和特殊值。

第二段代码的输出

创建实例时，实例内部的原型关联会指向构造函数在该时刻的 prototype 对象。后续把构造函数的 prototype 整体替换为另一个对象，不会追溯修改已经创建的实例。

function Ofo() {}

function Bick() {
  this.name = 'mybick'
}

var myBick = new Ofo()

Ofo.prototype = new Bick()

var youbick = new Bick()

console.log(myBick.name)  // undefined
console.log(youbick.name) // mybick

myBick 创建时，其原型关联指向旧的 Ofo.prototype。旧原型上没有 name 属性，所以读取 myBick.name 时，先检查实例自身，再沿旧原型链查找，最终得到 undefined。

执行 Ofo.prototype = new Bick() 后，新原型对象自身拥有 name 属性，但这一替换只影响之后通过 new Ofo() 创建的实例。它也不会影响 new Bick() 的正常行为。youbick 由 Bick 直接构造，构造函数把 name 写入实例自身，因此输出字符串 mybick。

可以增加一个新实例验证区别：

var nextBick = new Ofo()

console.log(nextBick.name) // mybick
console.log(Object.getPrototypeOf(myBick) === Ofo.prototype) // false
console.log(Object.getPrototypeOf(nextBick) === Ofo.prototype) // true

底层机制

执行 new Constructor() 时，可以概括为创建一个新对象、让该对象的内部原型指向 Constructor.prototype、以新对象作为 this 调用构造函数，并在构造函数没有显式返回对象时返回这个新对象。关键在于，实例记录的是对当时原型对象的关联，而不是对 Constructor.prototype 这个属性位置的动态订阅。

因此，修改原型对象上的属性与替换整个原型对象是两种不同操作：

function Person() {}
const first = new Person()

Person.prototype.role = 'user'
console.log(first.role) // user

Person.prototype = { role: 'admin' }
console.log(first.role) // user

第一次是在旧原型对象上新增属性，已有实例可以看到；第二次是替换构造函数的原型属性，已有实例仍然连接旧对象。

工程场景与边界

在运行期间整体替换构造函数原型容易造成同类实例拥有不同原型链，影响方法查找、类型判断和维护性。若确实采用构造函数继承，应在创建实例之前完成原型配置，并补回正确的 constructor 属性。现代业务代码通常可使用 class 语法表达继承，但它只是提供更清晰的语法和约束，底层方法查找仍建立在原型机制上。

还要注意，写入 obj.b 和读取 obj.b 的行为并不完全对称。读取会沿原型链查找；普通赋值通常在接收者自身创建或更新属性，但原型链上的访问器、只读属性以及代理对象可能改变这一行为。

常见误区与面试追问

常见误区包括：认为对象参数不是值传递；认为重新给形参赋值会替换外部对象；认为修改 Constructor.prototype 会同步更新已有实例；以及认为实例的 constructor 属性是创建实例时自动复制到实例自身的。实际上，默认的 constructor 通常来自原型对象，整体替换原型后可能丢失或指向错误对象。

面试中可继续追问：new 操作符具体执行哪些步骤、实例属性与原型属性发生同名遮蔽时如何查找、如何用 Object.getPrototypeOf 检查真实原型、为什么不建议依赖非标准的 __proto__ 修改原型，以及浅拷贝和深拷贝分别能隔离哪些变更。

8:[["$","header",null,{"className":"learn-hero","children":["$","div",null,{"className":"learn-hero-inner mx-auto max-w-[1320px] px-4 sm:px-6","children":[["$","nav",null,{"className":"flex items-center gap-1.5 text-[12.5px]","style":{"color":"var(--learn-text-dim)"},"aria-label":"面包屑","children":[["$","$L1a",null,{"href":"/flashcards","className":"inline-flex items-center gap-1","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-chevron-left size-3.5","aria-hidden":true,"children":[["$","path","1wnfg3",{"d":"m15 18-6-6 6-6"}],"$undefined"]}],"知识卡片"]}],["$","span",null,{"aria-hidden":true,"children":"/"}],["$","$L1a",null,{"href":"/flashcards/react","children":"React"}]]}],["$","div",null,{"className":"mt-4","children":["$","span",null,{"className":"learn-chip learn-chip-accent","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-sparkles size-3.5","aria-hidden":true,"children":[["$","path","1s2grr",{"d":"M11.017 2.814a1 1 0 0 1 1.966 0l1.051 5.558a2 2 0 0 0 1.594 1.594l5.558 1.051a1 1 0 0 1 0 1.966l-5.558 1.051a2 2 0 0 0-1.594 1.594l-1.051 5.558a1 1 0 0 1-1.966 0l-1.051-5.558a2 2 0 0 0-1.594-1.594l-5.558-1.051a1 1 0 0 1 0-1.966l5.558-1.051a2 2 0 0 0 1.594-1.594z"}],["$","path","1rf3ol",{"d":"M20 2v4"}],["$","path","gwowj6",{"d":"M22 4h-4"}],["$","circle","6kqj1y",{"cx":"4","cy":"20","r":"2"}],"$undefined"]}],"React"]}]}],["$","h1",null,{"className":"learn-title-mark mt-4 text-[27px] leading-[1.25] font-semibold tracking-tight sm:text-[34px]","children":"中级 07"}],["$","p",null,{"className":"mt-3 max-w-[640px] pl-4 text-[14.5px] leading-[1.8]","style":{"color":"var(--learn-text-dim)"},"children":"React中级题库第 7 组，共 2 张卡片。"}],["$","dl",null,{"className":"learn-num mt-5 flex flex-wrap items-center gap-x-6 gap-y-2 text-[13px]","style":{"color":"var(--learn-text-dim)"},"children":[["$","div",null,{"className":"inline-flex items-center gap-1.5","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-layers size-3.5","aria-hidden":true,"children":[["$","path","zw3jo",{"d":"M12.83 2.18a2 2 0 0 0-1.66 0L2.6 6.08a1 1 0 0 0 0 1.83l8.58 3.91a2 2 0 0 0 1.66 0l8.58-3.9a1 1 0 0 0 0-1.83z"}],["$","path","1wduqc",{"d":"M2 12a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 12"}],["$","path","kqbvx6",{"d":"M2 17a1 1 0 0 0 .58.91l8.6 3.91a2 2 0 0 0 1.65 0l8.58-3.9A1 1 0 0 0 22 17"}],"$undefined"]}],["$","dt",null,{"className":"sr-only","children":"卡片数"}],["$","dd",null,{"children":[2," 张卡"]}]]}],["$","div",null,{"className":"inline-flex items-center gap-1.5","children":[["$","svg",null,{"ref":"$undefined","xmlns":"http://www.w3.org/2000/svg","width":24,"height":24,"viewBox":"0 0 24 24","fill":"none","stroke":"currentColor","strokeWidth":2,"strokeLinecap":"round","strokeLinejoin":"round","className":"lucide lucide-clock3 lucide-clock-3 size-3.5","aria-hidden":true,"children":[["$","path","135r8i",{"d":"M12 6v6h4"}],["$","circle","1mglay",{"cx":"12","cy":"12","r":"10"}],"$undefined"]}],["$","dt",null,{"className":"sr-only","children":"预估时长"}],["$","dd",null,{"children":["约 ",3," 分钟"]}]]}],null]}]]}]}],["$","div",null,{"className":"mx-auto max-w-[1320px] px-4 pt-8 pb-16 sm:px-6","children":["$","div",null,{"className":"grid gap-6 lg:grid-cols-[minmax(0,1fr)_300px]","children":[["$","div",null,{"className":"max-w-[860px] min-w-0","children":[["$","$L21",null,{"node":{"id":"react-g2-07","trackKey":"react","title":"中级 07","summary":"React中级题库第 7 组，共 2 张卡片。","prerequisites":[],"cardCount":2,"estimatedMinutes":3,"preview":false,"bankCategory":"React","sourceType":"bank"},"trackTitle":"React","cards":[{"id":"bank-3d32a27a6a7c9621000d1b487b31abe7","trackKey":"react","nodeId":"react-g2-07","type":"recall","difficulty":2,"prompt":"实现 Redux Thunk 异步动作中间件","hints":[],"answer":"redux-thunk 的核心能力并不是让归约函数异步执行，而是扩展 dispatch 可接受的动作类型。","keyPoints":["核心思路","执行流程","复杂度分析","边界用例","常见错误","面试追问"],"explanation":"$22","tags":["react"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/3d32a27a6a7c9621000d1b487b31abe7"},"sourceType":"bank","sourcePath":"cloudbase://questionList/3d32a27a6a7c9621000d1b487b31abe7","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"3d32a27a6a7c9621000d1b487b31abe7","bankUpdateTime":"2026-08-12T15:47:30.583Z","explanationHtml":"$23","promptHtml":"实现 Redux Thunk 异步动作中间件","promptDetailHtml":"","answerHtml":"redux-thunk 的核心能力并不是让归约函数异步执行，而是扩展 dispatch 可接受的动作类型。","hintsHtml":[],"keyPointsHtml":["核心思路","执行流程","复杂度分析","边界用例","常见错误","面试追问"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{}},{"id":"bank-43af56d46a7c95da0001b35736a2e373","trackKey":"react","nodeId":"react-g2-07","type":"recall","difficulty":2,"prompt":"对象引用传递与构造函数原型变更会产生什么输出","hints":[],"answer":"代码中的变量 a 保存了对象 { b: 3 } 的引用。","keyPoints":["第一段代码的输出","第二段代码的输出","底层机制","工程场景与边界","常见误区与面试追问"],"explanation":"$24","tags":["react"],"readMore":{"title":"在题库里看这道题","path":"/weapp-interview/43af56d46a7c95da0001b35736a2e373"},"sourceType":"bank","sourcePath":"cloudbase://questionList/43af56d46a7c95da0001b35736a2e373","sourceAnchor":"","sourceHash":"","generatorVersion":1,"contentVersion":1,"bankQuestionId":"43af56d46a7c95da0001b35736a2e373","bankUpdateTime":"2026-08-12T15:47:30.583Z","explanationHtml":"$25","promptHtml":"对象引用传递与构造函数原型变更会产生什么输出","promptDetailHtml":"","answerHtml":"代码中的变量 a 保存了对象 { b: 3 } 的引用。","hintsHtml":[],"keyPointsHtml":["第一段代码的输出","第二段代码的输出","底层机制","工程场景与边界","常见误区与面试追问"],"followUpHtml":"","followUpAnswerHtml":"","optionsHtml":{}}]}],"$L26"]}],"$L27"]}]}],"$L28"]

实现 Redux Thunk 异步动作中间件

1实现 Redux Thunk 异步动作中间件

2对象引用传递与构造函数原型变更会产生什么输出